home *** CD-ROM | disk | FTP | other *** search
/ Whiteline: delta / whiteline CD Series - delta.iso / progtool / c / egem_210 / egem_ut1.lzh / EGEM_UT / SOURCE / WINVIEW / WINVIEW.C < prev    next >
Encoding:
C/C++ Source or Header  |  1994-09-22  |  17.7 KB  |  607 lines
  1.  
  2. /* Datei-Viewer (optional auch als Clipboard-Viewer durch Definition
  3.    des Makros 'CLIPVIEW', s. 'CLIPVIEW.PRJ') als "nützliches" Beispiel-
  4.    programm zur  EnhancedGEM-Library
  5.    (läuft als Programm und als Accessory), (c) 1994 C. Grunenberg */
  6.  
  7. /* Clipboard-Viewer:  Wertet die Nachrichten AV_PATH_UPDATE, SC_CHANGED
  8.                       und SH_WDRAW aus, um eine Veränderung des Clipboards
  9.                       festzustellen. Per Doppelklick oder Ctrl-O/H/V kann
  10.                       die Anzeige manuell aktualisiert werden
  11.  
  12.    Datei-Viewer:      Unterstützt sowohl Drag & Drop nach allen gängigen
  13.                          Varianten als auch das View-Protokoll und die
  14.                          Nachricht VA_START. Dargestellt werden können mono-
  15.                          chrome Images, Texte und Binärdateien als Dump.
  16.                          Per Doppelklick oder Ctrl-O/H kann der Fileselector
  17.                          aufgerufen werden. */
  18.  
  19. #include "winview.h"
  20.  
  21. /* Wird die folgende Definition eingebunden, so haben die Fenster
  22.    keine Slider. Die Library hat damit natürlich keine Probleme und
  23.    man kann die volle Geschwindigkeit der Scrollroutinen genießen, d.h.
  24.    man kann weiterhin per Tastatur oder Maus (Mausklick in Arbeitsbereich
  25.    und bei gedrückter Maustaste die Maus in gewünschte Richtung verschieben)
  26.    scrollen */
  27.  
  28. /*
  29. #undef GADGETS
  30. #define GADGETS    NAME|CLOSER|FULLER|MOVER|INFO|SIZER|UPARROW|DNARROW|LFARROW|RTARROW|SMALLER
  31. */
  32.  
  33. /* verschiedene Mausformen für die Funktion window_set_mouse() */
  34. MFORM mouse_v = {7,7,1,BLACK,WHITE,
  35. { 0x0180, 0x03C0, 0x07E0, 0x0FF0, 0x07E0, 0x03C0, 0x03C0, 0x03C0,
  36.   0x03C0, 0x03C0, 0x03C0, 0x07E0, 0x0FF0, 0x07E0, 0x03C0, 0x0180 },
  37. { 0x0000, 0x0180, 0x03C0, 0x05A0, 0x0180, 0x0180, 0x0180, 0x0180,
  38.   0x0180, 0x0180, 0x0180, 0x0180, 0x05A0, 0x03C0, 0x0180, 0x0000 }};
  39.  
  40. MFORM mouse_h = {7,7,1,BLACK,WHITE,
  41. { 0x0000, 0x0000, 0x0000, 0x0000, 0x1008, 0x381C, 0x7FFE, 0xFFFF,
  42.   0xFFFF, 0x7FFE, 0x381C, 0x1008, 0x0000, 0x0000, 0x0000, 0x0000 },
  43. { 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1008, 0x2004, 0x7FFE,
  44.   0x7FFE, 0x2004, 0x1008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 }};
  45.  
  46. MFORM mouse_vh = {7,7,1,BLACK,WHITE,
  47. { 0x0180, 0x03C0, 0x07E0, 0x0FF0, 0x17E8, 0x3BDC, 0x7FFE, 0xFFFF,
  48.   0xFFFF, 0x7FFE, 0x3BDC, 0x17E8, 0x0FF0, 0x07E0, 0x03C0, 0x0180 },
  49. { 0x0000, 0x0180, 0x03C0, 0x05A0, 0x0180, 0x1188, 0x2184, 0x7FFE,
  50.   0x7FFE, 0x2184, 0x1188, 0x0180, 0x05A0, 0x03C0, 0x0180, 0x0000 }};
  51.  
  52. /* Scancodes für Tastaturscrolling */
  53. KEY scroll_keys[] = {
  54. {SCANUP,PAGE_UP,LINE_UP},
  55. {SCANDOWN,PAGE_DOWN,LINE_DOWN},
  56. {SCANLEFT,LINE_START,LINE_LEFT},
  57. {SCANRIGHT,LINE_END,LINE_RIGHT},
  58. {SCANHOME,WIN_END,WIN_START} };
  59.  
  60. /* SCROLL-Struktur für automatisches Scrolling */
  61. SCROLL scroll;
  62.  
  63. /* Zeiger auf Fenster-Struktur */
  64. WIN *window;
  65.  
  66. /* Rechteck für maximale Fensterausmaße */
  67. GRECT max_win;
  68.  
  69. /* Zeichenkette für Infozeile des Fensters */
  70. char info[256];
  71.  
  72. #ifdef CLIPVIEW
  73.  
  74. char *entry = "  ClipboardViewer";        /* Eintrag im DESK-Menü */
  75. char *xacc_name = "ClipboardViewer";    /* XAcc2-Programmname */
  76. char *av_name = "CLIPVIEW";                /* AV-Programmname */
  77. char *title = "ClipboardViewer";        /* Fenster-Titel */
  78. char *small_title = "ClipView";            /* und im ikonifizierten Zustand */
  79.  
  80. #else
  81.  
  82. char *entry = "  WindowViewer";            /* Eintrag im DESK-Menü */
  83.  
  84. /* XAcc2-Programmname */
  85. char *xacc_name = "WindowViewer\0XDSC\0""1Dateiviewer\0""2View\0NView\0X.ASC\0X.HEX\0XDump\0X.IMG\0";
  86.  
  87. char *av_name = "WINVIEW";                /* AV-Programmname */
  88. char *title = "WindowViewer";            /* Fenster-Titel */
  89.  
  90. /* Fenster-Titel im ikonifizierten Zustand zeigt auf Dateinamen der
  91.    geladenen Datei */
  92. #define small_title    GetFilename(file_loaded)
  93.  
  94. /* Pfad- und Dateinamen */
  95. char path[MAX_PATH],fname[MAX_PATH];
  96.  
  97. #endif
  98.  
  99. /***********************************************************************
  100.  Fehlermeldung ausgeben
  101. ***********************************************************************/
  102. void error(int icon,char *msg)
  103. {
  104.     xalert(1,1,icon,NULL,SYS_MODAL,BUTTONS_RIGHT,TRUE,title,msg,"[Got it!");
  105. }
  106.  
  107. /***********************************************************************
  108.  Fenster-Scroll-Struktur initialisieren
  109.  ***********************************************************************/
  110. void SetWindow(void)
  111. {
  112.     scroll.hpos = scroll.vpos = 0;    /* linke/obere Ecke */
  113.  
  114.     switch (loaded)
  115.     {
  116.     /* Image geladen */
  117.     case TRUE:
  118.         scroll.hsize = img_w;                    /* Spalten = Breite */ 
  119.         scroll.vsize = img_h;                    /* Zeilen = Höhe */
  120.         scroll.px_hline = scroll.px_vline = 1;    /* Breite/Höhe einer Spalte/Zeile in Pixel */
  121.         scroll.hscroll = scroll.vscroll = 4;    /* Scroll-Schrittweite */
  122.         /* Infozeile des Fensters setzen */
  123.         sprintf(info," %s, %d x %d Pixel",file_loaded,img_w,img_h);
  124.         break;
  125.     /* Text- oder Binär-Datei (Dump) geladen */
  126.     case FAIL:
  127.         scroll.hsize = text_rows + text_tabs*(tab_size-1) + 1;    /* Spalten */
  128.         scroll.vsize = text_lines;                /* Zeilen */
  129.         scroll.px_hline = gr_cw;                /* Breite einer Spalte in Pixel */
  130.         scroll.px_vline = gr_ch;                /* Höhe einer Zeile in Pixel */
  131.         scroll.hscroll = scroll.vscroll = 1;    /* Scroll-Schrittweite */
  132.  
  133.         /* Text-Datei geladen? */
  134.         if (ascii)
  135.             /* Infozeile des Fensters setzen */
  136.             sprintf(info," %s, %d Line(s), Tab: %d",file_loaded,text_lines,tab_size);
  137.         else
  138.             /* Infozeile des Fensters setzen */
  139.             sprintf(info," %s, %ld Bytes",file_loaded,dump_size);
  140.         break;
  141. #ifdef CLIPVIEW
  142.     default:
  143.         /* Keine Datei geladen */
  144.         scroll.hsize = scroll.vsize = 0;        /* keine Zeilen/Spalten */
  145.         strcpy(info," No file in clipboard.");    /* Infozeile des Fensters setzen */
  146. #endif
  147.     }
  148. }
  149.  
  150. /***********************************************************************
  151.  Fenster schließen, Speicher freigeben und Programm beenden
  152. ***********************************************************************/
  153. void CloseWindow(void)
  154. {
  155.     if (window)                        /* Fenster geöffnet? */
  156.     {
  157.         ClearData();                /* Speicher freigeben */
  158.         close_window(window,FALSE);    /* Fenster schließen (keine Shrink-Boxen) */
  159.         window = NULL;
  160.         if (!_app)
  161.             MouseArrow();            /* Maus zurücksetzen, falls als Accessory geladen */
  162.     }
  163.  
  164.     if (_app)                        /* Als Programm gestartet? */
  165.         exit_gem(0);                /* Programm beenden (Rückgabewert: 0) */
  166. }
  167.  
  168. /***********************************************************************
  169.  Fenster-abhängige Mausform setzen
  170.  ***********************************************************************/
  171. void Mouse(void)
  172. {
  173.     int mouse,dx,dy;
  174.     MFORM *mf;
  175.  
  176.     /* benutzerdefinierte Mausform */
  177.     mouse = USER_DEF;
  178.  
  179.     /* Fensterinhalt breiter als eine Fensterseite? */
  180.     dx = scroll.hsize-scroll.hpage;
  181.  
  182.     /* Fensterinhalt höher als eine Fensterseite? */
  183.     dy = scroll.vsize-scroll.vpage;
  184.  
  185.     /* vertikales & horizontales Scrolling möglich? */
  186.     if (dx>0 && dy>0)
  187.         mf = &mouse_vh;
  188.     /* horizontales Scrolling möglich? */
  189.     else if (dx>0)
  190.         mf = &mouse_h;
  191.     /* vertikales Scrolling möglich? */
  192.     else if (dy>0)
  193.         mf = &mouse_v;
  194.     else
  195.     {
  196.         /* ansonsten Maus auf Fadenkreuz (Image) bzw. Text-Cursor (Text,
  197.            Dump) innerhalb des Arbeitsbereichs setzen */
  198.         mouse = (loaded==TRUE) ? THIN_CROSS : TEXT_CRSR;
  199.         mf = NULL;
  200.     }
  201.  
  202.     /* Mausform setzen (außerhalb des Arbeitsbereichs als Pfeil) */
  203.     window_set_mouse(window,mouse,ARROW,mf,NULL);
  204. }
  205.  
  206. /***********************************************************************
  207.  Fenster öffnen, evtl. Fileselector aufrufen und Datei laden
  208. ***********************************************************************/
  209. void OpenWindow(char *file)
  210. {
  211. #ifdef CLIPVIEW
  212.     /* vorherigen Clipboard-Inhalt löschen */
  213.     ClearData();
  214.  
  215.     /* Clipboard-Dateien (Image, Text) suchen */
  216.     if (scrp_find("img.txt.asc.rtf.tex.csv.eps.*",file_loaded))
  217.         /* Datei laden, falls vorhanden */
  218.         LoadData(file_loaded);
  219.  
  220.     /* Scroll-Struktur initialisieren */
  221.     SetWindow();
  222.  
  223.     /* maximale Fensterausmaße in Abhängigkeit vom Ladezustand berechnen */
  224.     if (loaded)
  225.         window_border(GADGETS,0,0,scroll.hsize*scroll.px_hline,scroll.vsize*scroll.px_vline,&max_win);
  226.     else
  227.     {
  228.         max_win = desk;
  229.         max_win.g_w >>= 1;
  230.         max_win.g_h >>= 1;
  231.     }
  232. #else
  233.     /* Pfad- und Dateiname übergeben? */
  234.     if (file && *GetFilename(file)=='\0')
  235.     {
  236.         /* nur Pfad übergeben */
  237.         strcpy(path,file);
  238.         file = NULL;
  239.     }
  240.  
  241.     /* Fileselector aufrufen, falls keine Datei übergeben wurde */
  242.     if (file || FileSelect("Load file...",path,fname,NULL,TRUE))
  243.     {
  244.         /* kompletten Pfad der Datei kopieren/erstellen */
  245.         if (file)
  246.             strcpy(file_loaded,file);
  247.         else
  248.             MakeFullpath(file_loaded,path,fname);
  249.  
  250.         /* Datei laden */
  251.         if (LoadData(file_loaded))    /* Wurde Datei geladen? */
  252.         {
  253.             /* Scroll-Struktur initialisieren */
  254.             SetWindow();
  255.             /* maximale Fensterausmaße berechnen */
  256.             window_border(GADGETS,0,0,scroll.hsize*scroll.px_hline,scroll.vsize*scroll.px_vline,&max_win);
  257. #endif
  258.             /* Fenster noch nicht geöffnet? */
  259.             if (window==NULL)
  260.             {
  261.                 /* Fenster öffnen */
  262.                 window = open_window(title,small_title,info,NULL,GADGETS,FALSE,MINSIZE,MINSIZE,&max_win,&desk,&scroll,Draw);
  263.                 if (window==NULL)
  264.                     /* Fenster konnte nicht geöffnet werden */
  265.                     error(X_ICN_ALERT,"No more windows available!");
  266.             }
  267.             else
  268.             {
  269.             #ifndef CLIPVIEW
  270.                 /* Größe auf Maximalbereich setzen */
  271.                 window->curr = max_win;
  272.             #endif
  273.                 /* Fenster reinitialisieren (Fensterausmaße, -titel, -infozeile) */
  274.                 window->max = max_win;
  275.                 window_reinit(window,title,small_title,info,TRUE);
  276.             }
  277. #ifndef CLIPVIEW
  278.         }
  279.         /* keine Datei geladen? */
  280.         else if (loaded==FALSE)
  281.             /* Nein -> Fenster schließen, falls vorher geöffnet */
  282.             CloseWindow();
  283.     }
  284. #endif
  285.  
  286.     /* Fenster geöffnet? */
  287.     if (window)
  288.         /* Mauszeigerform setzen */
  289.         Mouse();
  290.     else
  291.         /* ansonsten evtl. Programm beenden */
  292.         CloseWindow();
  293. }
  294.  
  295. /***********************************************************************
  296.  Initialisierungs-Routine, welche die Event-Struktur setzt sowie die
  297.  Ereignisse, die von der Applikation benötigt werden, zurückgibt
  298. ***********************************************************************/
  299. int InitEvent(XEVENT *ev,int avail)
  300. {
  301.     /* auf Nachrichten und Tastendrücke warten */
  302.     int flags = MU_MESAG|MU_KEYBD;
  303.  
  304.     /* Fenster geöffnet? */
  305.     if (window)
  306.     {
  307.         /* Fenster ist oberstes Fenster sowie nicht ikonifiziert und
  308.            erstes Rechtech-Ereignis ist verfügbar? */
  309.         if (window->inside>=0 && (avail & MU_M1))
  310.         {
  311.             /* Betreten/Verlassen des Arbeitsbereiches überwachen */
  312.             ev->ev_mm1flags = window->inside;
  313.             *(GRECT *) &ev->ev_mm1x = window->work;
  314.             flags |= MU_M1;
  315.         }
  316.  
  317.         /* erstes Button-Ereignis verfügbar? */
  318.         if (avail & MU_BUTTON1)
  319.         {
  320.             /* Einfach-/Doppelklick links */
  321.             ev->ev_mb1clicks = 2;
  322.             ev->ev_mb1state = ev->ev_mb1mask = 1;
  323.             flags |= MU_BUTTON1;
  324.         }
  325.     }
  326.  
  327.     /* gewünschte Ereignisse zurückgeben */
  328.     return (flags & avail);
  329. }
  330.  
  331. /***********************************************************************
  332.  Ereignisauswertung (AES-Nachrichten, Mausklicks/-bewegung, Tastendrücke)
  333. ***********************************************************************/
  334. int Event(XEVENT *ev)
  335. {
  336.     WIN *win;
  337.     int *msg,wich = ev->ev_mwich,scan,state,used=0,i,k,x,y,old_x,old_y;
  338.     KEY *keys;
  339.  
  340. #ifdef CLIPVIEW
  341.     char scrap[MAX_PATH],*path;
  342. #endif
  343.  
  344.     /* Mausklick links? */
  345.     if (wich & MU_BUTTON1)
  346.     {
  347.         /* Doppelklick links? */
  348.         if (ev->ev_mbreturn==2)
  349.             /* Fileselector aufrufen und Text laden */
  350.             OpenWindow(NULL);
  351.         /* Einfackklick in Arbeitsbereich und Fenster nicht ikonifiziert? */
  352.         else if (!window->iconified && rc_inside(ev->ev_mmox,ev->ev_mmoy,&window->work))
  353.         {
  354.             /* Durch dieses Codesegment kann man den Fensterinhalt scrollen,
  355.                indem man in das Fenster klickt und bei gedrückter Maustaste
  356.                die Maus bewegt! */
  357.  
  358.             /* alte Mausposition merken */
  359.             old_x = ev->ev_mmox;
  360.             old_y = ev->ev_mmoy;
  361.  
  362.             /* Maus ausschalten und wind_update()-Status setzen */
  363.             wind_update(BEG_MCTRL);
  364.             MouseOff();
  365.  
  366.             do
  367.             {
  368.                 /* Maustaste und -position ermitteln */
  369.                 graf_mkstate(&x,&y,&k,&i);
  370.                 /* Wurde Maus bewegt? */
  371.                 if (x!=old_x || y!=old_y)
  372.                 {
  373.                     /* entsprechend der Verschiebung die Fensterposition
  374.                        ändern */
  375.                     scroll.hpos += (x-old_x)*scroll.hscroll;
  376.                     scroll.vpos += (y-old_y)*scroll.vscroll;
  377.                     /* Fenster scrollen */
  378.                     scroll_window(window,WIN_SCROLL,NULL);
  379.                     /* Mausposition merken */
  380.                     old_x = x;
  381.                     old_y = y;
  382.                 }
  383.             } while (k & 1);    /* solange linke Maustaste gedrückt */
  384.  
  385.             /* Maus anschalten und wind_update()-Status löschen */
  386.             MouseOn();
  387.             wind_update(END_MCTRL);
  388.         }
  389.  
  390.         /* Button-Event wurde ausgewertet */
  391.         used |= MU_BUTTON1;
  392.     }
  393.  
  394.     /* Maus-Ereignis? (Maus hat Arbeitsbereich betreten/verlassen) */
  395.     if (wich & MU_M1)
  396.     {
  397.         /* Mausform aktualisieren */
  398.         window_mouse(window);
  399.         /* Mouse-Event wurde ausgewertet */
  400.         used |= MU_M1;
  401.     }
  402.  
  403.     /* Nachricht vom AES oder der Library? */
  404.     if (wich & MU_MESAG)
  405.     {
  406.         /* Adresse des Nachrichten-Puffers */
  407.         msg = ev->ev_mmgpbuf;
  408.  
  409.         /* Fenster zu Fenster-Nachricht ermitteln */
  410.         win = get_window(msg[3]);
  411.  
  412.         /* Event wurde ausgewertet */
  413.         used |= MU_MESAG;
  414.  
  415.         switch (msg[0])
  416.         {
  417.         case AC_OPEN:
  418.             /* (Fileselector aufrufen und) Datei/Klemmbrett laden */
  419.             OpenWindow(NULL);
  420.             break;
  421.         case AC_CLOSE:
  422.         case AP_TERM:
  423.         case WM_CLOSED:
  424.             /* Fenster schließen und Programm evtl. beenden */
  425.             CloseWindow();
  426.             break;
  427.         case WM_TOPPED:
  428.             /* Fenster nach oben holen */
  429.             window_top(win);
  430.             break;
  431.         case WM_BOTTOMED:
  432.             /* Fenster nach unten legen */
  433.             window_bottom(win);
  434.             break;
  435.         case WM_FULLED:
  436.             /* Fenster auf maximale oder vorherige Ausmaße setzen */
  437.             *(GRECT *) &msg[4] = (win->fulled) ? win->prev : win->max;
  438.         case WM_SIZED:
  439.         case WM_MOVED:
  440.             /* neue Fensterposition/-größe setzen */
  441.             window_size(win,(GRECT *) &msg[4]);
  442.             /* Mausform setzen */
  443.             Mouse();
  444.             break;
  445.         #ifdef CLIPVIEW
  446.         /* Inhalt eines Laufwerks wurde verändert */
  447.         case SH_WDRAW:
  448.             /* Klemmbrett vorhanden? */
  449.             if (scrp_path(scrap,NULL))
  450.                 /* Alle Laufwerke oder das Klemmbrett-Laufwerk betroffen? */    
  451.                 if (msg[3]<0 || GetDrive(scrap)==msg[3])
  452.                     /* Klemmbrett aktualisieren */
  453.                     OpenWindow(NULL);
  454.             break;
  455.         /* Inhalt eines Pfades wurde verändert */
  456.         case AV_PATH_UPDATE:
  457.             /* Klemmbrett vorhanden? */
  458.             if (scrp_path(scrap,NULL))
  459.             {
  460.                 /* Pfad, dessen Inhalt sich geändert hat */
  461.                 path = *(char **) &msg[3];
  462.                 /* übergeordneter Pfad des Klemmbretts? */
  463.                 if (!strnicmp(scrap,path,strlen(path)))
  464.                     /* Klemmbrett aktualisieren */
  465.                     OpenWindow(NULL);
  466.             }
  467.             break;
  468.         /* Inhalt des Klemmbretts hat sich geändert */
  469.         case SC_CHANGED:
  470.             /* Klemmbrett aktualisieren */
  471.             OpenWindow(NULL);
  472.             break;
  473.         #else
  474.         /* Datei soll angezeigt werden (View-Protokoll) */
  475.         case VIEW_FILE:
  476.             /* Nachricht positiv beantworten */
  477.             AvSendMsg(msg[1],VIEW_OPEN,msg);
  478.             /* Datei laden und anzeigen */
  479.             OpenWindow(*(char **) &msg[3]);
  480.             break;
  481.         /* Datei/Pfad wurde per Drag&Drop übergeben */
  482.         case OBJC_DRAGGED:
  483.             /* Datei laden und anzeigen */
  484.             OpenWindow((*(DRAG_DROP **) &msg[4])->dd_args);
  485.             break;
  486.         #endif
  487.         default:
  488.             /* unbekannte Nachricht konnte nicht ausgewertet werden */
  489.             used &= ~MU_MESAG;
  490.         }
  491.     }
  492.  
  493.     /* Tastatur-Ereignis? */
  494.     if (wich & MU_KEYBD)
  495.     {
  496.         /* Status der Umschalttasten */
  497.         state = ev->ev_mmokstate;
  498.         /* Scancode der gedrückten Taste */
  499.         scan = ev->ev_mkreturn;
  500.         /* Zeichen der gedrückten Taste ermitteln */
  501.         k = scan_2_ascii(scan,state);
  502.         scan >>= 8;
  503.  
  504.         /* Control-Taste gedrückt? */
  505.         if (state & K_CTRL)
  506.         {
  507.             /* Keyboard-Event wurde ausgewertet */
  508.             used |= MU_KEYBD;
  509.  
  510.             /* Pfeil links und Datei geladen? */
  511.             if (scan==CTRLLEFT)
  512.             {
  513.                 if (loaded)
  514.                     /* Seite nach links scrollen */
  515.                     scroll_window(window,PAGE_LEFT,NULL);
  516.             }
  517.             /* Pfeil rechts und Datei geladen? */
  518.             else if (scan==CTRLRIGHT)
  519.             {
  520.                 if (loaded)
  521.                     /* Seite nach rechts scrollen */
  522.                     scroll_window(window,PAGE_RIGHT,NULL);
  523.             }
  524.             /* Ctrl-Q oder Ctrl-U? */
  525.             else if (strchr("QU",k))
  526.                 /* Fenster schließen und evtl. Programm beenden */
  527.                 CloseWindow();
  528.         #ifdef CLIPVIEW
  529.             /* Ctrl-O, Ctrl-H oder Ctrl-V? */
  530.             else if (strchr("OHV",k))
  531.                 /* Klemmbrett aktualisieren */
  532.         #else
  533.             /* Ctrl-O oder Ctrl-H? */
  534.             else if (strchr("OH",k))
  535.                 /* Fileselector aufrufen und Datei laden */
  536.         #endif
  537.                 OpenWindow(NULL);
  538.             else
  539.                 /* unbekannte Taste */
  540.                 used &= ~MU_KEYBD;
  541.         }
  542.         /* Datei geladen? */
  543.         else if (loaded)
  544.         {
  545.             /* Tab-Taste gedrückt? */
  546.             if (scan==SCANTAB)
  547.             {
  548.                 /* neue Tabulator-Größe setzen */
  549.                 if (tab_size==0)
  550.                     tab_size++;
  551.                 else
  552.                     tab_size = (tab_size*2)&15;
  553.  
  554.                 /* Fenster initialisieren, falls es sich um eine Text-
  555.                    Datei handelt und diese Tabulatoren enthält */
  556.                 if (loaded==FAIL && ascii && text_tabs)
  557.                 {
  558.                     SetWindow();
  559.                     window_reinit(window,title,small_title,info,FALSE);
  560.                 }
  561.  
  562.                 used |= MU_KEYBD;
  563.             }
  564.             else
  565.                 /* Pfeil-Taste -> Fenster scrollen */
  566.                 for (keys=&scroll_keys[0],i=0;i<sizeof(scroll_keys);i++,keys++)
  567.                     if (keys->scan==scan)
  568.                     {
  569.                         scroll_window(window,(state & (K_RSHIFT|K_LSHIFT)) ? keys->shift : keys->norm,NULL);
  570.                         used |= MU_KEYBD;
  571.                         break;
  572.                     }
  573.         }
  574.     }
  575.  
  576.     /* ausgewertete Ereignisse zurückgeben */
  577.     return (used);
  578. }
  579.  
  580. void main(int argc,char **argv)
  581. {
  582.     /* Bibliothek sowie AES, VDI und Protokolle initialisieren
  583.        (keine anwendungspezifische AV/XAcc-Nachrichtenauswertung,
  584.         Clipboard-Viewer unterstützt AV_PATH_UPDATE)) */
  585.     if (init_gem(entry,xacc_name,av_name,0,0,0)==TRUE)
  586.     {
  587.         /* automatisches Scrolling */
  588.         scroll.scroll = TRUE;
  589.  
  590.     #ifndef CLIPVIEW
  591.         /* aktuellen Pfad ermitteln (für Fileselectoraufruf) */
  592.         getcwd(path,(int) sizeof(path));
  593.     #endif
  594.  
  595.         /* Ereignis-Routinen anmelden */
  596.         Event_Handler(InitEvent,Event);
  597.  
  598.         /* als Programm gestartet? */
  599.         if (_app)
  600.             /* Fileselector aufrufen oder übergebene Datei laden */
  601.             OpenWindow((argc>1) ? argv[1] : NULL);
  602.  
  603.         /* ...und los geht's */
  604.         Event_Multi(NULL);
  605.     }
  606. }
  607.